/*******************************************************************************
 * Copyright (c) 2000, 2004 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Common Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/cpl-v10.html
 * 
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
module dwt.widgets.decorations;


private import dwt.dwt;


private import dwt.widgets.button;
public import dwt.widgets.canvas;
private import dwt.widgets.composite;
private import dwt.widgets.control;
private import dwt.widgets.display;
private import dwt.widgets.event;
private import dwt.widgets.menu;
private import dwt.widgets.menuitem;
private import dwt.widgets.shell;
private import dwt.internal.win32.os;

private import dwt.graphics.point;
private import dwt.graphics.rectangle;
private import dwt.graphics.image;
private import dwt.graphics.imagedata;
private import dwt.util.util;

/**
 * Instances of this class provide the appearance and
 * behavior of <code>Shells</code>, but are not top
 * level shells or dialogs. Class <code>Shell</code>
 * shares a significant amount of code with this class,
 * and is a subclass.
 * <p>
 * IMPORTANT: This class was intended to be abstract and
 * should <em>never</em> be referenced or instantiated.
 * Instead, the class <code>Shell</code> should be used.
 * </p>
 * <p>
 * Instances are always displayed in one of the maximized, 
 * minimized or normal states:
 * <ul>
 * <li>
 * When an instance is marked as <em>maximized</em>, the
 * window manager will typically resize it to fill the
 * entire visible area of the display, and the instance
 * is usually put in a state where it can not be resized 
 * (even if it has style <code>RESIZE</code>) until it is
 * no longer maximized.
 * </li><li>
 * When an instance is in the <em>normal</em> state (neither
 * maximized or minimized), its appearance is controlled by
 * the style constants which were specified when it was created
 * and the restrictions of the window manager (see below).
 * </li><li>
 * When an instance has been marked as <em>minimized</em>,
 * its contents (client area) will usually not be visible,
 * and depending on the window manager, it may be
 * "iconified" (that is, replaced on the desktop by a small
 * simplified representation of itself), relocated to a
 * distinguished area of the screen, or hidden. Combinations
 * of these changes are also possible.
 * </li>
 * </ul>
 * </p>
 * Note: The styles supported by this class must be treated
 * as <em>HINT</em>s, since the window manager for the
 * desktop on which the instance is visible has ultimate
 * control over the appearance and behavior of decorations.
 * For example, some window managers only support resizable
 * windows and will always assume the RESIZE style, even if
 * it is not set.
 * <dl>
 * <dt><b>Styles:</b></dt>
 * <dd>BORDER, CLOSE, MIN, MAX, NO_TRIM, RESIZE, TITLE, ON_TOP, TOOL</dd>
 * <dt><b>Events:</b></dt>
 * <dd>(none)</dd>
 * </dl>
 * Class <code>DWT</code> provides two "convenience constants"
 * for the most commonly required style combinations:
 * <dl>
 * <dt><code>SHELL_TRIM</code></dt>
 * <dd>
 * the result of combining the constants which are required
 * to produce a typical application top level shell: (that 
 * is, <code>CLOSE | TITLE | MIN | MAX | RESIZE</code>)
 * </dd>
 * <dt><code>DIALOG_TRIM</code></dt>
 * <dd>
 * the result of combining the constants which are required
 * to produce a typical application dialog shell: (that 
 * is, <code>TITLE | CLOSE | BORDER</code>)
 * </dd>
 * </dl>
 * <p>
 * IMPORTANT: This class is intended to be subclassed <em>only</em>
 * within the DWT implementation.
 * </p>
 *
 * @see #getMinimized
 * @see #getMaximized
 * @see Shell
 * @see DWT
 */

public class Decorations : Canvas {
	
	Image image, smallImage, largeImage;
	Image [] images;
	Menu menuBar;
	Menu [] menus;
	Control savedFocus;
	Button defaultButton, saveDefault;
	int swFlags, nAccel;
	HACCEL hAccel;

/**
 * Prevents uninitialized instances from being created outside the package.
 */
this () {
}

/**
 * Constructs a new instance of this class given its parent
 * and a style value describing its behavior and appearance.
 * <p>
 * The style value is either one of the style constants defined in
 * class <code>DWT</code> which is applicable to instances of this
 * class, or must be built by <em>bitwise OR</em>'ing together 
 * (that is, using the <code>int</code> "|" operator) two or more
 * of those <code>DWT</code> style constants. The class description
 * lists the style constants that are applicable to the class.
 * Style bits are also inherited from superclasses.
 * </p>
 *
 * @param parent a composite control which will be the parent of the new instance (cannot be null)
 * @param style the style of control to construct
 *
 * @exception IllegalArgumentException <ul>
 *    <li>ERROR_NULL_ARGUMENT - if the parent is null</li>
 * </ul>
 * @exception SWTException <ul>
 *    <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the parent</li>
 *    <li>ERROR_INVALID_SUBCLASS - if this class is not an allowed subclass</li>
 * </ul>
 *
 * @see DWT#BORDER
 * @see DWT#CLOSE
 * @see DWT#MIN
 * @see DWT#MAX
 * @see DWT#RESIZE
 * @see DWT#TITLE
 * @see DWT#NO_TRIM
 * @see DWT#SHELL_TRIM
 * @see DWT#DIALOG_TRIM
 * @see DWT#ON_TOP
 * @see DWT#TOOL
 * @see Widget#checkSubclass
 * @see Widget#getStyle
 */
public this (Composite parent, int style) {
	super (parent, checkStyle (style));
}

void addMenu (Menu menu) {
	if (menus is null) menus = new Menu [4];
	for (int i=0; i<menus.length; i++) {
		if (menus [i] is null) {
			menus [i] = menu;
			return;
		}
	}
	Menu [] newMenus = new Menu [menus.length + 4];
	newMenus [menus.length] = menu;
	System.arraycopy (menus, 0, newMenus, 0, menus.length);
	menus = newMenus;
}

void bringToTop () {
	/*
	* This code is intentionally commented.  On some platforms,
	* the ON_TOP style creates a shell that will stay on top
	* of every other shell on the desktop.  Using SetWindowPos ()
	* with HWND_TOP caused problems on Windows 98 so this code is
	* commented out until this functionality is specified and
	* the problems are fixed.
	*/
//	if ((style & DWT.ON_TOP) != 0) {
//		int flags = OS.SWP_NOSIZE | OS.SWP_NOMOVE | OS.SWP_NOACTIVATE; 
//		OS.SetWindowPos (handle, OS.HWND_TOP, 0, 0, 0, 0, flags);
//	} else {
		OS.BringWindowToTop (handle);
//	}
}

static int checkStyle (int style) {
	version(WinCE) {
		/*
		* Feature in WinCE PPC.  WS_MINIMIZEBOX or WS_MAXIMIZEBOX
		* are not supposed to be used.  If they are, the result
		* is a button which does not repaint correctly.  The fix
		* is to remove this style.
		*/
		if ((style & DWT.MIN) != 0) style &= ~DWT.MIN;
		if ((style & DWT.MAX) != 0) style &= ~DWT.MAX;
		return style;
	}

	/*
	* If either WS_MINIMIZEBOX or WS_MAXIMIZEBOX are set,
	* we must also set WS_SYSMENU or the buttons will not
	* appear.
	*/
	if ((style & (DWT.MIN | DWT.MAX)) != 0) style |= DWT.CLOSE;
	
	/*
	* Both WS_SYSMENU and WS_CAPTION must be set in order
	* to for the system menu to appear.
	*/
	if ((style & DWT.CLOSE) != 0) style |= DWT.TITLE;
	
	/*
	* Bug in Windows.  The WS_CAPTION style must be
	* set when the window is resizable or it does not
	* draw properly.
	*/
	/*
	* This code is intentionally commented.  It seems
	* that this problem originally in Windows 3.11,
	* has been fixed in later versions.  Because the
	* exact nature of the drawing problem is unknown,
	* keep the commented code around in case it comes
	* back.
	*/
//	if ((style & DWT.RESIZE) != 0) style |= DWT.TITLE;
	
	return style;
}

protected void checkSubclass () {
	if (!isValidSubclass ()) error(__FILE__, __LINE__, DWT.ERROR_INVALID_SUBCLASS);
}

LRESULT callWindowProc (int msg, int wParam, int lParam) {
	return OS.DefMDIChildProc (handle, msg, wParam, lParam);
}

Control computeTabGroup () {
	return this;
}

Control computeTabRoot () {
	return this;
}

public Rectangle computeTrim (int x, int y, int width, int height) {
	checkWidget ();

	/* Get the size of the trimmings */
	RECT rect;
	OS.SetRect (&rect, x, y, x + width, y + height);
	int bits = OS.GetWindowLong (handle, OS.GWL_STYLE);

	version(WinCE)
	{
	boolean hasMenu = false;
	}
	else
	{
	boolean hasMenu = (OS.GetMenu (handle) !is null);
	}
	
	
	OS.AdjustWindowRectEx (&rect, bits, hasMenu, OS.GetWindowLong (handle, OS.GWL_EXSTYLE));

	/* Get the size of the scroll bars */
	if (horizontalBar !is null) rect.bottom += OS.GetSystemMetrics (OS.SM_CYHSCROLL);
	if (verticalBar !is null) rect.right += OS.GetSystemMetrics (OS.SM_CXVSCROLL);

	/* Get the height of the menu bar */
	if (hasMenu) {
		RECT testRect;
		OS.SetRect (&testRect, 0, 0, rect.right - rect.left, rect.bottom - rect.top);
		OS.SendMessage (handle, OS.WM_NCCALCSIZE, 0, &testRect);
		while ((testRect.bottom - testRect.top) < height) {
			rect.top -= OS.GetSystemMetrics (OS.SM_CYMENU) - OS.GetSystemMetrics (OS.SM_CYBORDER);
			OS.SetRect(&testRect, 0, 0, rect.right - rect.left, rect.bottom - rect.top);
			OS.SendMessage (handle, OS.WM_NCCALCSIZE, 0, &testRect);
		}
	}
	return new Rectangle (rect.left, rect.top, rect.right - rect.left, rect.bottom - rect.top);
}

void createAccelerators () {
	hAccel = null; 
	nAccel = 0;
	int maxAccel = 0;
	MenuItem [] items = display.items;
	if (menuBar is null || items is null) {
		if (!OS.IsPPC) return;
		maxAccel = 1;
	} else {
		maxAccel = OS.IsPPC ? items.length + 1 : items.length;
	}
	ACCEL* accel = new ACCEL ();
	byte [] buffer1 = new byte [ACCEL.sizeof];	
	byte [] buffer2 = new byte [maxAccel * ACCEL.sizeof];
	if (menuBar !is null && items !is null) {
		for (int i=0; i<items.length; i++) {
			MenuItem item = items [i];
			if (item !is null && item.accelerator != 0) {
				Menu menu = item.parent;
				if (menu.parent is this) {
					while (menu !is null && menu !is menuBar) {
						menu = menu.getParentMenu ();
					}
					if (menu is menuBar) {
						item.fillAccel (accel);
						OS.MoveMemory (buffer1.ptr, accel, ACCEL.sizeof);
						System.arraycopy (buffer1, 0, buffer2, nAccel * ACCEL.sizeof, ACCEL.sizeof);
						nAccel++;
					}
				}
			}
		}
	}
	if (OS.IsPPC) {
		/* 
		* Note on WinCE PPC.  Close the shell when user taps CTRL-Q.
		* IDOK represents the "Done Button" which also closes the shell.
		*/
		accel.fVirt = cast(byte) (OS.FVIRTKEY | OS.FCONTROL);
		accel.key = cast(short) 'Q';
		accel.cmd = cast(short) OS.IDOK;
		OS.MoveMemory (buffer1.ptr, accel, ACCEL.sizeof);
		System.arraycopy (buffer1, 0, buffer2, nAccel * ACCEL.sizeof, ACCEL.sizeof);
		nAccel++;			
	}
	if (nAccel != 0) hAccel = OS.CreateAcceleratorTable (cast(ACCEL*)buffer2, nAccel);
}

void createHandle () {
	super.createHandle ();
	if (parent is null) return;
	setParent ();
	setSystemMenu ();
}

void createWidget () {
	super.createWidget ();

	version(WinCE){
	swFlags = OS.SW_SHOWMAXIMIZED;
	}else{
	swFlags = OS.SW_SHOWNOACTIVATE;
	}
	
	hAccel = OS.INVALID_HANDLE_VALUE;
}

void destroyAccelerators () {
	if (hAccel !is null && hAccel !is OS.INVALID_HANDLE_VALUE) OS.DestroyAcceleratorTable (hAccel);
	hAccel = OS.INVALID_HANDLE_VALUE;
}

public void dispose () {
	if (isDisposed()) return;
	if (!isValidThread ()) error(__FILE__, __LINE__, DWT.ERROR_THREAD_INVALID_ACCESS);
	if (!(cast(Shell)this)) {
		setVisible (false);
		if (!traverseDecorations (false)) {
			Shell shell = getShell ();
			shell.setFocus ();
		}
	}
	super.dispose ();
}

Menu findMenu (HMENU hMenu) {
	if (menus is null) return null;
	for (int i=0; i<menus.length; i++) {
		Menu menu = menus [i];
		if (menu !is null && hMenu is menu.handle) return menu;
	}
	return null;
}

void fixDecorations (Decorations newDecorations, Control control, Menu [] menus) {
	if (this is newDecorations) return;
	if (control is savedFocus) savedFocus = null;
	if (control is defaultButton) defaultButton = null;
	if (control is saveDefault) saveDefault = null;
	if (menus is null) return;
	Menu menu = control.menu;
	if (menu !is null) {
		int index = 0;
		while (index <menus.length) {
			if (menus [index] is menu) {
				control.setMenu (null);
				return;
			}
			index++;
		}
		menu.fixMenus (newDecorations);
		destroyAccelerators ();
		newDecorations.destroyAccelerators ();
	}
}

public Rectangle getBounds () {
	checkWidget ();
	version(WinCE) { } else {
		if (OS.IsIconic (handle)) {
			WINDOWPLACEMENT lpwndpl;
			lpwndpl.length = WINDOWPLACEMENT.sizeof;
			OS.GetWindowPlacement (handle, &lpwndpl);
			int width = lpwndpl.rcNormalPosition.right - lpwndpl.rcNormalPosition.left;
			int height = lpwndpl.rcNormalPosition.bottom - lpwndpl.rcNormalPosition.top;
			return new Rectangle (lpwndpl.rcNormalPosition.left, lpwndpl.rcNormalPosition.top, width, height);
		}
	}
	return super.getBounds ();
}

public Rectangle getClientArea () {
	checkWidget ();
	/* 
	* Note: The CommandBar is part of the client area,
	* not the trim.  Applications don't expect this so
	* subtract the height of the CommandBar.
	*/
	version(WinCE) {
	if (OS.IsHPC) {
		Rectangle rect = super.getClientArea ();
		if (menuBar !is null) {
			HWND hwndCB = menuBar.hwndCB;
			int height = OS.CommandBar_Height (hwndCB);
			rect.y += height;
			rect.height -= height;
		}
		return rect;
	}
	}
	version(WinCE) { } else {
		if (OS.IsIconic (handle)) {
			RECT rect;
			WINDOWPLACEMENT lpwndpl;
			lpwndpl.length = WINDOWPLACEMENT.sizeof;
			OS.GetWindowPlacement (handle, &lpwndpl);
			int width = lpwndpl.rcNormalPosition.right - lpwndpl.rcNormalPosition.left;
			int height = lpwndpl.rcNormalPosition.bottom - lpwndpl.rcNormalPosition.top;
			OS.SetRect (&rect, 0, 0, width, height);
			OS.SendMessage (handle, OS.WM_NCCALCSIZE, 0, &rect);
			return new Rectangle (0, 0, rect.right, rect.bottom);
		}
	}
	return super.getClientArea ();
}

/**
 * Returns the receiver's default button if one had
 * previously been set, otherwise returns null.
 *
 * @return the default button or null
 *
 * @exception SWTException <ul>
 *    <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li>
 *    <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li>
 * </ul>
 *
 * @see #setDefaultButton
 */
public Button getDefaultButton () {
	checkWidget ();
	return defaultButton;
}

/**
 * Returns the receiver's image if it had previously been 
 * set using <code>setImage()</code>. The image is typically
 * displayed by the window manager when the instance is
 * marked as iconified, and may also be displayed somewhere
 * in the trim when the instance is in normal or maximized
 * states.
 * <p>
 * Note: This method will return null if called before
 * <code>setImage()</code> is called. It does not provide
 * access to a window manager provided, "default" image
 * even if one exists.
 * </p>
 * 
 * @return the image
 *
 * @exception SWTException <ul>
 *    <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li>
 *    <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li>
 * </ul>
 */
public Image getImage () {
	checkWidget ();
	return image;
}

/**
 * Returns the receiver's images if they had previously been 
 * set using <code>setImages()</code>. Images are typically
 * displayed by the window manager when the instance is
 * marked as iconified, and may also be displayed somewhere
 * in the trim when the instance is in normal or maximized
 * states. Depending where the icon is displayed, the platform
 * chooses the icon with the "best" size. It is expected that
 * the array will contain the same icon rendered at different
 * resolutions.
 * 
 * <p>
 * Note: This method will return an empty array if called before
 * <code>setImages()</code> is called. It does not provide
 * access to a window manager provided, "default" image
 * even if one exists.
 * </p>
 * 
 * @return the images
 *
 * @exception SWTException <ul>
 *    <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li>
 *    <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li>
 * </ul>
 * 
 * @since 3.0
 */
public Image [] getImages () {
	checkWidget ();
	if (images is null) return new Image [0];
	Image [] result = new Image [images.length];
	System.arraycopy (images, 0, result, 0, images.length);
	return result;
}

public Point getLocation () {
	checkWidget ();
	version(WinCE) { } else {
		if (OS.IsIconic (handle)) {
			WINDOWPLACEMENT lpwndpl;
			lpwndpl.length = WINDOWPLACEMENT.sizeof;
			OS.GetWindowPlacement (handle, &lpwndpl);
			return new Point (lpwndpl.rcNormalPosition.left, lpwndpl.rcNormalPosition.top);
		}
	}
	return super.getLocation ();
}

/**
 * Returns <code>true</code> if the receiver is currently
 * maximized, and false otherwise. 
 * <p>
 *
 * @return the maximized state
 *
 * @exception SWTException <ul>
 *    <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li>
 *    <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li>
 * </ul>
 *
 * @see #setMaximized
 */
public boolean getMaximized () {
	checkWidget ();
	version(WinCE) { return swFlags == OS.SW_SHOWMAXIMIZED; }
	if (OS.IsWindowVisible (handle)) return cast(boolean)(OS.IsZoomed (handle));
	return swFlags == OS.SW_SHOWMAXIMIZED;
}

/**
 * Returns the receiver's menu bar if one had previously
 * been set, otherwise returns null.
 *
 * @return the menu bar or null
 *
 * @exception SWTException <ul>
 *    <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li>
 *    <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li>
 * </ul>
 */
public Menu getMenuBar () {
	checkWidget ();
	return menuBar;
}

/**
 * Returns <code>true</code> if the receiver is currently
 * minimized, and false otherwise. 
 * <p>
 *
 * @return the minimized state
 *
 * @exception SWTException <ul>
 *    <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li>
 *    <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li>
 * </ul>
 *
 * @see #setMinimized
 */
public boolean getMinimized () {
	checkWidget ();
	version(WinCE) { return false; }
	if (OS.IsWindowVisible (handle)) return cast(boolean)(OS.IsIconic (handle));
	return swFlags == OS.SW_SHOWMINNOACTIVE;
}

char[] getNameText () {
	return getText ();
}

public Point getSize () {
	checkWidget ();
	version(WinCE) { } else {
		if (OS.IsIconic (handle)) {
			WINDOWPLACEMENT lpwndpl;
			lpwndpl.length = WINDOWPLACEMENT.sizeof;
			OS.GetWindowPlacement (handle, &lpwndpl);
			int width = lpwndpl.rcNormalPosition.right - lpwndpl.rcNormalPosition.left;
			int height = lpwndpl.rcNormalPosition.bottom - lpwndpl.rcNormalPosition.top;
			return new Point (width, height);
		}
	}
	return super.getSize ();
}

/**
 * Returns the receiver's text, which is the string that the
 * window manager will typically display as the receiver's
 * <em>title</em>. If the text has not previously been set, 
 * returns an empty string.
 *
 * @return the text
 *
 * @exception SWTException <ul>
 *    <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li>
 *    <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li>
 * </ul>
 */
public char[] getText () {
	checkWidget ();
	return OS.GetWindowText (handle);
}

public boolean isReparentable () {
	checkWidget ();
	/*
	* Feature in Windows.  Calling SetParent() for a shell causes
	* a kind of fake MDI to happen.  It doesn't work well on Windows
	* and is not supported on the other platforms.  The fix is to
	* disallow the SetParent().
	*/
	return false;
}

boolean isTabGroup () {
	/*
	* Can't test WS_TAB bits because they are the same as WS_MAXIMIZEBOX.
	*/
	return true;
}

boolean isTabItem () {
	/*
	* Can't test WS_TAB bits because they are the same as WS_MAXIMIZEBOX.
	*/
	return false;
}

Decorations menuShell () {
	return this;
}

void releaseWidget () {
	if (menuBar !is null) menuBar.releaseResources ();
	menuBar = null;
	if (menus !is null) {
		do {
			int index = 0;
			while (index < menus.length) {
				Menu menu = menus [index];
				if (menu !is null && !menu.isDisposed ()) {
					while (menu.getParentMenu () !is null) {
						menu = menu.getParentMenu ();
					}
					menu.dispose ();
					break;
				}
				index++;
			}
			if (index == menus.length) break;
		} while (true);
	}
	menus = null;
	super.releaseWidget ();
	if (smallImage !is null) smallImage.dispose ();
	if (largeImage !is null) largeImage.dispose ();
	smallImage = largeImage = image = null;
	images = null;
	savedFocus = null;
	defaultButton = saveDefault = null;
	if (hAccel !is null && hAccel !is OS.INVALID_HANDLE_VALUE) OS.DestroyAcceleratorTable (hAccel);
	hAccel = OS.INVALID_HANDLE_VALUE;
}

void removeMenu (Menu menu) {
	if (menus is null) return;
	for (int i=0; i<menus.length; i++) {
		if (menus [i] is menu) {
			menus [i] = null;
			return;
		}
	}
}

boolean restoreFocus () {
	if (display.ignoreRestoreFocus) return true;
	if (savedFocus !is null && savedFocus.isDisposed ()) savedFocus = null;
	if (savedFocus !is null && savedFocus.setSavedFocus ()) return true;
	/*
	* This code is intentionally commented.  When no widget
	* has been given focus, some platforms give focus to the
	* default button.  Windows doesn't do this.
	*/
//	if (defaultButton !is null && !defaultButton.isDisposed ()) {
//		if (defaultButton.setFocus ()) return true;
//	}
	return false;
}

void saveFocus () {
	Control control = display.getFocusControl ();
	if (control !is null && control !is this && this is control.menuShell ()) {
		setSavedFocus (control);
	}
}

void setBounds5 (int x, int y, int width, int height, int flags) {
	version(WinCE) {
		super.setBounds (x, y, width, height, flags);
	}
	if (OS.IsIconic (handle) || OS.IsZoomed (handle)) {
		setPlacement (x, y, width, height, flags);
		return;
	}
	super.setBounds5 (x, y, width, height, flags);
}

/**
 * If the argument is not null, sets the receiver's default
 * button to the argument, and if the argument is null, sets
 * the receiver's default button to the first button which
 * was set as the receiver's default button (called the 
 * <em>saved default button</em>). If no default button had
 * previously been set, or the saved default button was
 * disposed, the receiver's default button will be set to
 * null. 
 *
 * @param button the new default button
 *
 * @exception IllegalArgumentException <ul>
 *    <li>ERROR_INVALID_ARGUMENT - if the button has been disposed</li> 
 * </ul>
 * @exception SWTException <ul>
 *    <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li>
 *    <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li>
 * </ul>
 */
public void setDefaultButton (Button button) {
	checkWidget ();
	setDefaultButton (button, true);
}

void setDefaultButton (Button button, boolean save) {
	if (button is null) {
		if (defaultButton is saveDefault) {
			if (save) saveDefault = null;
			return;
		}
	} else {
		if (button.isDisposed()) error(__FILE__, __LINE__, DWT.ERROR_INVALID_ARGUMENT);
		if ((button.style & DWT.PUSH) == 0) return;
		if (button is defaultButton) return;
	}
	if (defaultButton !is null) {
		if (!defaultButton.isDisposed ()) defaultButton.setDefault (false);
	}
	if ((defaultButton = button) is null) defaultButton = saveDefault;
	if (defaultButton !is null) {
		if (!defaultButton.isDisposed ()) defaultButton.setDefault (true);
	}
	if (save) saveDefault = defaultButton;
	if (saveDefault !is null && saveDefault.isDisposed ()) saveDefault = null;
}

/**
 * Sets the receiver's image to the argument, which may
 * be null. The image is typically displayed by the window
 * manager when the instance is marked as iconified, and
 * may also be displayed somewhere in the trim when the
 * instance is in normal or maximized states.
 * 
 * @param image the new image (or null)
 *
 * @exception IllegalArgumentException <ul>
 *    <li>ERROR_INVALID_ARGUMENT - if the image has been disposed</li> 
 * </ul>
 * @exception SWTException <ul>
 *    <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li>
 *    <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li>
 * </ul>
 */
public void setImage (Image image) {
	checkWidget ();
	if (image !is null && image.isDisposed ()) error(__FILE__, __LINE__, DWT.ERROR_INVALID_ARGUMENT);
	this.image = image;
	setImages (image, null);
}

void setImages (Image image, Image [] images) {
	/*
	* Feature in WinCE.  WM_SETICON and WM_GETICON set the icon
	* for the window class, not the window instance.  This means
	* that it is possible to set an icon into a window and then
	* later free the icon, thus freeing the icon for every window.
	* The fix is to avoid the API.
	* 
	* On WinCE PPC, icons in windows are not displayed.
	*/
	version(WinCE) { return; }
	if (smallImage !is null) smallImage.dispose ();
	if (largeImage !is null) largeImage.dispose ();
	smallImage = largeImage = null;
	HICON hSmallIcon = null, hLargeIcon = null;
	Image smallIcon = null, largeIcon = null;
	int smallWidth = 0x7FFFFFFF, largeWidth = 0x7FFFFFFF;
	if (image !is null) {
		Rectangle rect = image.getBounds ();
		smallWidth = Math.abs (rect.width - OS.GetSystemMetrics (OS.SM_CXSMICON));
		smallIcon = image;
		largeWidth = Math.abs (rect.width - OS.GetSystemMetrics (OS.SM_CXICON)); 
		largeIcon = image;
	}
	if (images !is null) {
		for (int i = 0; i < images.length; i++) {
			Rectangle rect = images [i].getBounds ();
			int value = Math.abs (rect.width - OS.GetSystemMetrics (OS.SM_CXSMICON));
			if (value < smallWidth) {
				smallWidth = value;
				smallIcon = images [i];
			}
			value = Math.abs (rect.width - OS.GetSystemMetrics (OS.SM_CXICON));
			if (value < largeWidth) {
				largeWidth = value;
				largeIcon = images [i];
			}
		}
	}
	if (smallIcon !is null) {
		switch (smallIcon.type) {
			case DWT.BITMAP:
				ImageData data = smallIcon.getImageData ();
				ImageData mask = data.getTransparencyMask ();
				smallImage = new Image (display, data, mask);
				hSmallIcon = smallImage.handle;
				break;
			case DWT.ICON:
				hSmallIcon = smallIcon.handle;
				break;
			default : break;
		}
	}
	OS.SendMessage (handle, OS.WM_SETICON, OS.ICON_SMALL, hSmallIcon);
	if (largeIcon !is null) {
		switch (largeIcon.type) {
			case DWT.BITMAP:
				ImageData data = largeIcon.getImageData ();
				ImageData mask = data.getTransparencyMask ();
				largeImage = new Image (display, data, mask);
				hLargeIcon = largeImage.handle;
				break;
			case DWT.ICON:
				hLargeIcon = largeIcon.handle;
				break;
			default : break;
		}
	}
	OS.SendMessage (handle, OS.WM_SETICON, OS.ICON_BIG, hLargeIcon);
	
	/*
	* Bug in Windows.  When WM_SETICON is used to remove an
	* icon from the window trimmings for a window with the
	* extended style bits WS_EX_DLGMODALFRAME, the window
	* trimmings do not redraw to hide the previous icon.
	* The fix is to force a redraw.
	*/
	version(WinCE) { } else {
		if (hSmallIcon is null && hLargeIcon is null && (style & DWT.BORDER) != 0) {
			int flags = OS.RDW_FRAME | OS.RDW_INVALIDATE;
			OS.RedrawWindow (handle, null, null, flags);
		}
	}
}

/**
 * Sets the receiver's images to the argument, which may
 * be an empty array. Images are typically displayed by the
 * window manager when the instance is marked as iconified,
 * and may also be displayed somewhere in the trim when the
 * instance is in normal or maximized states. Depending where
 * the icon is displayed, the platform chooses the icon with
 * the "best" size. It is expected that the array will contain
 * the same icon rendered at different resolutions.
 * 
 * @param images the new image array
 *
 * @exception IllegalArgumentException <ul>
 *    <li>ERROR_NULL_ARGUMENT - if the array of images is null</li>
 *    <li>ERROR_INVALID_ARGUMENT - if one of the images has been disposed</li>
 * </ul>
 * @exception SWTException <ul>
 *    <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li>
 *    <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li>
 * </ul>
 * 
 * @since 3.0
 */
public void setImages (Image [] images) {
	checkWidget ();
	if (images is null) error(__FILE__, __LINE__, DWT.ERROR_INVALID_ARGUMENT);
	for (int i = 0; i < images.length; i++) {
		if (images [i] is null || images [i].isDisposed ()) error(__FILE__, __LINE__, DWT.ERROR_INVALID_ARGUMENT);
	}
	this.images = images;
	setImages (null, images);
}

/**
 * Sets the maximized state of the receiver.
 * If the argument is <code>true</code> causes the receiver
 * to switch to the maximized state, and if the argument is
 * <code>false</code> and the receiver was previously maximized,
 * causes the receiver to switch back to either the minimized
 * or normal states.
 * <p>
 * Note: The result of intermixing calls to<code>setMaximized(true)</code>
 * and <code>setMinimized(true)</code> will vary by platform. Typically,
 * the behavior will match the platform user's expectations, but not
 * always. This should be avoided if possible.
 * </p>
 *
 * @param maximized the new maximized state
 *
 * @exception SWTException <ul>
 *    <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li>
 *    <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li>
 * </ul>
 *
 * @see #setMinimized
 */
public void setMaximized (boolean maximized) {
	checkWidget ();
	swFlags = maximized ? OS.SW_SHOWMAXIMIZED : OS.SW_RESTORE;
	version(WinCE) {
		/*
		* Note: WinCE does not support SW_SHOWMAXIMIZED and SW_RESTORE. The
		* workaround is to resize the window to fit the parent client area.
		*/
		if (maximized) {
			RECT rect;
			OS.SystemParametersInfo (OS.SPI_GETWORKAREA, 0, rect, 0);
			int width = rect.right - rect.left, height = rect.bottom - rect.top;
			if (OS.IsPPC) {
				/* Leave space for the menu bar */
				if (menuBar !is null) {
					HWND hwndCB = menuBar.hwndCB;
					RECT rectCB;
					OS.GetWindowRect (hwndCB, &rectCB);
					height -= rectCB.bottom - rectCB.top;
				}
			}
			int flags = OS.SWP_NOZORDER | OS.SWP_DRAWFRAME | OS.SWP_NOACTIVATE;
			SetWindowPos (handle, 0, rect.left, rect.top, width, height, flags);	
		}
	} else {
		if (!OS.IsWindowVisible (handle)) return;
		if (maximized == OS.IsZoomed (handle)) return;
		OS.ShowWindow (handle, swFlags);
		OS.UpdateWindow (handle);
	}
}

/**
 * Sets the receiver's menu bar to the argument, which
 * may be null.
 *
 * @param menu the new menu bar
 *
 * @exception IllegalArgumentException <ul>
 *    <li>ERROR_INVALID_ARGUMENT - if the menu has been disposed</li> 
 *    <li>ERROR_INVALID_PARENT - if the menu is not in the same widget tree</li>
 * </ul>
 * @exception SWTException <ul>
 *    <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li>
 *    <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li>
 * </ul>
 */
public void setMenuBar (Menu menu) {
	checkWidget ();
	if (menuBar is menu) return;
	if (menu !is null) {
		if (menu.isDisposed()) error(__FILE__, __LINE__, DWT.ERROR_INVALID_ARGUMENT);
		if ((menu.style & DWT.BAR) == 0) error(__FILE__, __LINE__, DWT.ERROR_MENU_NOT_BAR);
		if (menu.parent !is this) error(__FILE__, __LINE__, DWT.ERROR_INVALID_PARENT);
	}	
	version(WinCE) {
		if (OS.IsHPC) {
			boolean resize = menuBar !is menu;
			if (menuBar !is null) OS.CommandBar_Show (menuBar.hwndCB, false);
			menuBar = menu;
			if (menuBar !is null) OS.CommandBar_Show (menuBar.hwndCB, true);
			if (resize) {
				sendEvent (DWT.Resize);
				layout (false);
			}
		} else {
			if (OS.IsPPC) {
				/*
				* Note in WinCE PPC.  The menu bar is a separate popup window.
				* If the shell is full screen, resize its window to leave
				* space for the menu bar.
				*/
				boolean resize = getMaximized () && menuBar !is menu;
				if (menuBar !is null) OS.ShowWindow (menuBar.hwndCB, OS.SW_HIDE);
				menuBar = menu;
				if (menuBar !is null) OS.ShowWindow (menuBar.hwndCB, OS.SW_SHOW);
				if (resize) setMaximized (true);
			}
			if (OS.IsSP) {
				if (menuBar !is null) OS.ShowWindow (menuBar.hwndCB, OS.SW_HIDE);
				menuBar = menu;
				if (menuBar !is null) OS.ShowWindow (menuBar.hwndCB, OS.SW_SHOW);
			}
		} 
	} else {
		if (menu !is null) display.removeBar (menu);
		menuBar = menu;
		HMENU hMenu = menuBar !is null ? menuBar.handle: null;
		OS.SetMenu (handle, hMenu);
	}
	destroyAccelerators ();
}

/**
 * Sets the minimized stated of the receiver.
 * If the argument is <code>true</code> causes the receiver
 * to switch to the minimized state, and if the argument is
 * <code>false</code> and the receiver was previously minimized,
 * causes the receiver to switch back to either the maximized
 * or normal states.
 * <p>
 * Note: The result of intermixing calls to<code>setMaximized(true)</code>
 * and <code>setMinimized(true)</code> will vary by platform. Typically,
 * the behavior will match the platform user's expectations, but not
 * always. This should be avoided if possible.
 * </p>
 *
 * @param minimized the new maximized state
 *
 * @exception SWTException <ul>
 *    <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li>
 *    <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li>
 * </ul>
 *
 * @see #setMaximized
 */
public void setMinimized (boolean minimized) {
	checkWidget ();
	version(WinCE) { return; }
	swFlags = minimized ? OS.SW_SHOWMINNOACTIVE : OS.SW_RESTORE;
	if (!OS.IsWindowVisible (handle)) return;
	if (minimized == OS.IsIconic (handle)) return;
	int flags = swFlags;
	if (flags == OS.SW_SHOWMINNOACTIVE && handle is OS.GetActiveWindow ()) {
		flags = OS.SW_MINIMIZE;
	}
	OS.ShowWindow (handle, flags);
	OS.UpdateWindow (handle);
}

void setParent () {
	/*
	* In order for an MDI child window to support
	* a menu bar, setParent () is needed to reset
	* the parent.  Otherwise, the MDI child window
	* will appear as a separate shell.  This is an
	* undocumented and possibly dangerous Windows
	* feature.
	*/
	HWND hwndParent = parent.handle;
	display.lockActiveWindow = true;
	OS.SetParent (handle, hwndParent);
	if (!OS.IsWindowVisible (hwndParent)) {
		OS.ShowWindow (handle, OS.SW_SHOWNA);
	}
	int bits = OS.GetWindowLong (handle, OS.GWL_STYLE);
	bits &= ~OS.WS_CHILD;
	OS.SetWindowLong (handle, OS.GWL_STYLE, bits | OS.WS_POPUP);
	OS.SetWindowLong (handle, OS.GWL_ID, 0);
	int flags = OS.SWP_NOSIZE | OS.SWP_NOMOVE | OS.SWP_NOACTIVATE; 
	SetWindowPos (handle, OS.HWND_BOTTOM, 0, 0, 0, 0, flags);
	display.lockActiveWindow = false;
}

void setPlacement (int x, int y, int width, int height, int flags) {
	WINDOWPLACEMENT lpwndpl;
	lpwndpl.length = WINDOWPLACEMENT.sizeof;
	OS.GetWindowPlacement (handle, &lpwndpl);
	lpwndpl.showCmd = OS.SW_SHOWNA;
	if (OS.IsIconic (handle)) {
		lpwndpl.showCmd = OS.SW_SHOWMINNOACTIVE;
	} else {
		if (OS.IsZoomed (handle)) {
			lpwndpl.showCmd = OS.SW_SHOWMAXIMIZED;
		}
	}
	if ((flags & OS.SWP_NOMOVE) == 0) {
		lpwndpl.rcNormalPosition.right = x + (lpwndpl.rcNormalPosition.right - lpwndpl.rcNormalPosition.left);
		lpwndpl.rcNormalPosition.bottom = y + (lpwndpl.rcNormalPosition.bottom - lpwndpl.rcNormalPosition.top);
		lpwndpl.rcNormalPosition.left = x;
		lpwndpl.rcNormalPosition.top = y;
	}
	if ((flags & OS.SWP_NOSIZE) == 0) {
		lpwndpl.rcNormalPosition.right = lpwndpl.rcNormalPosition.left + width;
		lpwndpl.rcNormalPosition.bottom = lpwndpl.rcNormalPosition.top + height;
	}
	OS.SetWindowPlacement (handle, &lpwndpl);
}

void setSavedFocus (Control control) {
	savedFocus = control;
}

void setSystemMenu () {
	version(WinCE) { return; }
	HMENU hMenu = OS.GetSystemMenu (handle, false);
	if (hMenu is null) return;
	int oldCount = OS.GetMenuItemCount (hMenu);
	if ((style & DWT.RESIZE) == 0) {
		OS.DeleteMenu (hMenu, OS.SC_SIZE, OS.MF_BYCOMMAND);
	}
	if ((style & DWT.MIN) == 0) {
		OS.DeleteMenu (hMenu, OS.SC_MINIMIZE, OS.MF_BYCOMMAND);
	}
	if ((style & DWT.MAX) == 0) {
		OS.DeleteMenu (hMenu, OS.SC_MAXIMIZE, OS.MF_BYCOMMAND);
	}
	if ((style & (DWT.MIN | DWT.MAX)) == 0) {
		OS.DeleteMenu (hMenu, OS.SC_RESTORE, OS.MF_BYCOMMAND);
	}
	int newCount = OS.GetMenuItemCount (hMenu);
	if ((style & DWT.CLOSE) == 0 || newCount != oldCount) {	
		OS.DeleteMenu (hMenu, OS.SC_TASKLIST, OS.MF_BYCOMMAND);
		MENUITEMINFO info;
		info.cbSize = MENUITEMINFO.sizeof;
		info.fMask = OS.MIIM_ID;
		int index = 0;
		while (index < newCount) {
			if (OS.GetMenuItemInfo (hMenu, index, true, &info)) {
				if (info.wID == OS.SC_CLOSE) break;
			}
			index++;
		}
		if (index != newCount) {
			OS.DeleteMenu (hMenu, index - 1, OS.MF_BYPOSITION);
			if ((style & DWT.CLOSE) == 0) {
				OS.DeleteMenu (hMenu, OS.SC_CLOSE, OS.MF_BYCOMMAND);
			}
		}
	}
}

/**
 * Sets the receiver's text, which is the string that the
 * window manager will typically display as the receiver's
 * <em>title</em>, to the argument, which may not be null. 
 *
 * @param string the new text
 *
 * @exception IllegalArgumentException <ul>
 *    <li>ERROR_NULL_ARGUMENT - if the text is null</li>
 * </ul>
 * @exception SWTException <ul>
 *    <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li>
 *    <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li>
 * </ul>
 */
public void setText (char[] string) {
	checkWidget ();
	if (string !is null) 
		OS.SetWindowText (handle, Converter.StrToTCHARz(string));
}

public void setVisible (boolean visible) {
	checkWidget ();
	if (drawCount != 0) {
		if (((state & HIDDEN) == 0) == visible) return;
	} else {
		if (visible == OS.IsWindowVisible (handle)) return;
	}
	if (visible) {
		/*
		* It is possible (but unlikely), that application
		* code could have disposed the widget in the show
		* event.  If this happens, just return.
		*/
		sendEvent (DWT.Show);
		if (isDisposed ()) return;
		version(WinCE){
		if (OS.IsHPC) {
			if (menuBar !is null) {
				HWND hwndCB = menuBar.hwndCB;
				OS.CommandBar_DrawMenuBar (hwndCB, 0);
			}
		}
		}
		if (drawCount != 0) {
			state &= ~HIDDEN;
		} else {
			version(WinCE) {
				OS.ShowWindow (handle, OS.SW_SHOW);
			} else {
				if (menuBar !is null) {
					display.removeBar (menuBar);
					OS.DrawMenuBar (handle);
				}
				OS.ShowWindow (handle, swFlags);
			}
			OS.UpdateWindow (handle);
		}
	} else {
		version(WinCE) { } else {
			if (OS.IsIconic (handle)) {
				swFlags = OS.SW_SHOWMINNOACTIVE;
			} else {
				if (OS.IsZoomed (handle)) {
					swFlags = OS.SW_SHOWMAXIMIZED;
				} else {
					if (handle is OS.GetActiveWindow ()) {
						swFlags = OS.SW_RESTORE;
					} else {
						swFlags = OS.SW_SHOWNOACTIVATE;
					}
				}
			}
		}
		if (drawCount != 0) {
			state |= HIDDEN;
		} else {
			OS.ShowWindow (handle, OS.SW_HIDE);
		}
		/*
		* It is possible (but unlikely), that application
		* code could have disposed the widget in an event
		* triggered by ShowWindow().  If this happens, just
		* return.
		*/
		if (isDisposed ()) return;
		sendEvent (DWT.Hide);
	}
}

boolean translateAccelerator (MSG* msg) {
	if (!isEnabled () || !isActive ()) return false;
	if (menuBar !is null && !menuBar.isEnabled ()) return false;
	if (translateMDIAccelerator (msg) || translateMenuAccelerator (msg)) return true;
	Decorations decorations = parent.menuShell ();
	return decorations.translateAccelerator (msg);
}

boolean translateMenuAccelerator (MSG* msg) {
	if (hAccel is OS.INVALID_HANDLE_VALUE) createAccelerators ();
	if( hAccel !is null && OS.TranslateAccelerator (handle, hAccel, msg) != 0)
		return true;
	return false;
}

boolean translateMDIAccelerator (MSG* msg) {
	if (!(cast(Shell)this)) {
		Shell shell = getShell ();
		HWND hwndMDIClient = shell.hwndMDIClient;
		if (hwndMDIClient !is null && OS.TranslateMDISysAccel (hwndMDIClient, msg)) {
			return true;
		}
		if (msg.message == OS.WM_KEYDOWN) {
			if (OS.GetKeyState (OS.VK_CONTROL) >= 0) return false;
			switch (msg.wParam) {
				case OS.VK_F4:
					OS.PostMessage (handle, OS.WM_CLOSE, 0, 0);
					return true;
				case OS.VK_F6:
					if (traverseDecorations (true)) return true;
				default : break;
			}
			return false;
		}
		if (msg.message == OS.WM_SYSKEYDOWN) {
			switch (msg.wParam) {
				case OS.VK_F4:
					OS.PostMessage (shell.handle, OS.WM_CLOSE, 0, 0);
					return true;
				default : break;
			}
			return false;
		}
	}
	return false;
}

boolean traverseDecorations (boolean next) {
	Control [] children = parent._getChildren ();
	int length = children.length;
	int index = 0;
	while (index < length) {
		if (children [index] is this) break;
		index++;
	}
	/*
	* It is possible (but unlikely), that application
	* code could have disposed the widget in focus in
	* or out events.  Ensure that a disposed widget is
	* not accessed.
	*/
	int start = index, offset = (next) ? 1 : -1;
	while ((index = (index + offset + length) % length) != start) {
		Control child = children [index];
		if (!child.isDisposed () && cast(Decorations)child) {
			if (child.setFocus ()) return true;
		}
	}
	return false;
}

boolean traverseItem (boolean next) {
	return false;
}

boolean traverseReturn () {
	if (defaultButton is null || defaultButton.isDisposed ()) return false;
	if (!defaultButton.isVisible () || !defaultButton.isEnabled ()) return false;
	defaultButton.click ();
	return true;
}

CREATESTRUCT* widgetCreateStruct () {
	return new CREATESTRUCT ();
}

int widgetExtStyle () {
	int bits = super.widgetExtStyle () | OS.WS_EX_MDICHILD;
	bits &= ~OS.WS_EX_CLIENTEDGE;
	if ((style & DWT.NO_TRIM) != 0) return bits;
	if (OS.IsPPC) {
		if ((style & DWT.CLOSE) != 0) bits |= OS.WS_EX_CAPTIONOKBTN;
	}
	if ((style & DWT.TOOL) != 0) bits |= OS.WS_EX_TOOLWINDOW;
	if ((style & DWT.RESIZE) != 0) return bits;
	if ((style & DWT.BORDER) != 0) bits |= OS.WS_EX_DLGMODALFRAME;
	return bits;
}

HWND widgetParent () {
	Shell shell = getShell ();
	return shell.hwndMDIClient ();
}

int widgetStyle () {
	/* 
	* Clear WS_VISIBLE and WS_TABSTOP.  NOTE: In Windows, WS_TABSTOP
	* has the same value as WS_MAXIMIZEBOX so these bits cannot be
	* used to control tabbing.
	*/
	int bits = super.widgetStyle () & ~(OS.WS_TABSTOP | OS.WS_VISIBLE);
	
	/* Set the title bits and no-trim bits */
	bits &= ~OS.WS_BORDER;
	if ((style & DWT.NO_TRIM) != 0) return bits;
	if ((style & DWT.TITLE) != 0) bits |= OS.WS_CAPTION;
	
	/* Set the min and max button bits */
	if ((style & DWT.MIN) != 0) bits |= OS.WS_MINIMIZEBOX;
	if ((style & DWT.MAX) != 0) bits |= OS.WS_MAXIMIZEBOX;
	
	/* Set the resize, dialog border or border bits */
	if ((style & DWT.RESIZE) != 0) {
		/*
		* Note on WinCE PPC.  DWT.RESIZE is used to resize
		* the Shell according to the state of the IME.
		* It does not set the WS_THICKFRAME style.
		*/
		if (!OS.IsPPC) bits |= OS.WS_THICKFRAME;	
	} else {
		if ((style & DWT.BORDER) == 0) bits |= OS.WS_BORDER;
	}

	/* Set the system menu and close box bits */
	if (!OS.IsPPC && !OS.IsSP) {
		if ((style & DWT.CLOSE) != 0) bits |= OS.WS_SYSMENU;
	}
	
	return bits;
}

int windowProc (HWND hwnd, int msg, int wParam, int lParam) {
	switch (msg) {
		case Display.DWT_GETACCEL:
		case Display.DWT_GETACCELCOUNT:
			if (hAccel is OS.INVALID_HANDLE_VALUE) createAccelerators ();
			return msg == Display.DWT_GETACCELCOUNT ? nAccel : cast(int)hAccel;
		default : break;
	}
	return super.windowProc (hwnd, msg, wParam, lParam);
}

LDWTRESULT WM_ACTIVATE_ (int wParam, int lParam) {
	LDWTRESULT result = super.WM_ACTIVATE_ (wParam, lParam);
	if (result !is null) return result;
	/*
	* Feature in AWT.  When an AWT Window is activated,
	* for some reason, it seems to forward the WM_ACTIVATE
	* message to the parent.  Normally, the parent is an
	* AWT Frame.  When AWT is embedded in DWT, the DWT
	* shell gets the WM_ACTIVATE and assumes that it came
	* from Windows.  When an DWT shell is activated it
	* restores focus to the last control that had focus.
	* If this control is an embedded composite, it takes
	* focus from the AWT Window.  The fix is to ignore
	* WM_ACTIVATE messages that come from AWT Windows.
	*/
//	if (OS.GetParent (lParam) == handle) {
//		String buffer = new String (0, 128);
//		OS.GetClassName (lParam, buffer, buffer.length);
//		String className = buffer.toString (0, buffer.strlen ());
//		if (std.string.cmp(className, Display.AWT_WINDOW_CLASS) == 0) {
//			return LRESULT.ONE;
//		}
//	}
	if ((wParam & 0xFFFF) != 0) {
		/*
		* When the high word of wParam is non-zero, the activation
		* state of the window is being changed while the window is
		* minimized. If this is the case, do not report activation
		* events or restore the focus.
		*/
		if ((wParam >> 16) != 0) return result;
		/*
		* It is possible (but unlikely), that application
		* code could have disposed the widget in the activate
		* event.  If this happens, end the processing of the
		* Windows message by returning zero as the result of
		* the window proc.
		*/
		Control control = display.findControl (cast(HWND)lParam);
		if (control is null || cast(Shell)control) {
			if (cast(Shell)this) {
				sendEvent (DWT.Activate);
				if (isDisposed ()) return LDWTRESULT.ZERO;
			}
		}
		if (restoreFocus ()) return LDWTRESULT.ZERO;	
	} else {
		/*
		* It is possible (but unlikely), that application
		* code could have disposed the widget in the deactivate
		* event.  If this happens, end the processing of the
		* Windows message by returning zero as the result of
		* the window proc.
		*/
		Control control = display.findControl (cast(HWND)lParam);
		if (control is null || cast(Shell)control) {
			if (cast(Shell)this) {
				Shell shell = getShell ();
				shell.setActiveControl (null);
				if (isDisposed ()) return LDWTRESULT.ZERO;
				sendEvent (DWT.Deactivate);
				if (isDisposed ()) return LDWTRESULT.ZERO;
			}
		}
		saveFocus ();
	}
	return result;
}

LDWTRESULT WM_CLOSE_ (int wParam, int lParam) {
	LDWTRESULT result = super.WM_CLOSE_ (wParam, lParam);
	if (result !is null) return result;
	if (!isEnabled () || !isActive ()) return LDWTRESULT.ZERO;
	Event event = new Event ();
	sendEvent (DWT.Close, event);
	// the widget could be disposed at this point
	if (event.doit && !isDisposed ()) dispose ();
	return LDWTRESULT.ZERO;
}

LDWTRESULT WM_HOTKEY_ (int wParam, int lParam) {
	LDWTRESULT result = super.WM_HOTKEY_ (wParam, lParam);
	if (result !is null) return result;
	version(WinCE){
	if (OS.IsSP) {
		/*
		* Feature on WinCE SP.  The Back key is either used to close
		* the foreground Dialog or used as a regular Back key in an EDIT
		* control. The article 'Back Key' in MSDN for Smartphone 
		* describes how an application should handle it.  The 
		* workaround is to override the Back key when creating
		* the menubar and handle it based on the style of the Shell.
		* If the Shell has the DWT.CLOSE style, close the Shell.
		* Otherwise, send the Back key to the window with focus.
		*/
		if (((lParam >> 16) & 0xFFFF) == OS.VK_ESCAPE) {
			if ((style & DWT.CLOSE) != 0) {
				OS.PostMessage (handle, OS.WM_CLOSE, 0, 0);
			} else {
				OS.SHSendBackToFocusWindow (OS.WM_HOTKEY, wParam, lParam);
			}
			return LDWTRESULT.ZERO;
		}
	}
	}
	return result;
}

LDWTRESULT WM_KILLFOCUS_ (int wParam, int lParam) {
	LDWTRESULT result  = super.WM_KILLFOCUS_ (wParam, lParam);
	saveFocus ();
	return result;
}

LDWTRESULT WM_NCACTIVATE_ (int wParam, int lParam) {
	LDWTRESULT result = super.WM_NCACTIVATE_ (wParam, lParam);
	if (result !is null) return result;
	if (wParam == 0) {
		if (display.lockActiveWindow) return LDWTRESULT.ZERO;
		Control control = display.findControl (cast(HWND)lParam);
		if (control !is null) {
			Shell shell = getShell ();
			Decorations decorations = control.menuShell ();
			if (decorations.getShell () is shell) {
				if (cast(Shell)this) return LDWTRESULT.ONE;
				if (display.ignoreRestoreFocus) {
					if (display.lastHittest != OS.HTCLIENT) {
						result = LDWTRESULT.ONE;
					}
				}
			}
		}
	}
	if (!(cast(Shell)this)) {
		HWND hwndShell = getShell().handle;
		OS.SendMessage (hwndShell, OS.WM_NCACTIVATE, wParam, lParam);
	}
	return result;
}

LDWTRESULT WM_QUERYOPEN_ (int wParam, int lParam) {
	LDWTRESULT result = super.WM_QUERYOPEN_ (wParam, lParam);
	if (result !is null) return result;
	sendEvent (DWT.Deiconify);
	// widget could be disposed at this point
	return result;
}

LDWTRESULT WM_SETFOCUS_ (int wParam, int lParam) {
	LDWTRESULT result = super.WM_SETFOCUS_ (wParam, lParam);
	if (savedFocus !is this) restoreFocus ();
	return result;
}

LDWTRESULT WM_SIZE_ (int wParam, int lParam) {
	LDWTRESULT result = super.WM_SIZE_ (wParam, lParam);
	/*
	* It is possible (but unlikely), that application
	* code could have disposed the widget in the resize
	* event.  If this happens, end the processing of the
	* Windows message by returning the result of the
	* WM_SIZE message.
	*/
	if (isDisposed ()) return result;
	if (wParam == OS.SIZE_MINIMIZED) {
		sendEvent (DWT.Iconify);
		// widget could be disposed at this point
	}
	return result;
}

LDWTRESULT WM_SYSCOMMAND_ (int wParam, int lParam) {
	LDWTRESULT result = super.WM_SYSCOMMAND_ (wParam,lParam);
	if (result !is null) return result;
	if (!(cast(Shell)this)) {
		int cmd = wParam & 0xFFF0;
		switch (cmd) {
			case OS.SC_CLOSE: {
				OS.PostMessage (handle, OS.WM_CLOSE, 0, 0);
				return LDWTRESULT.ZERO;
			}
			case OS.SC_NEXTWINDOW: {
				traverseDecorations (true);
				return LDWTRESULT.ZERO;
			}
			default : break;
		}
	}
	return result;
}

LDWTRESULT WM_WINDOWPOSCHANGING_ (int wParam, int lParam) {
	LDWTRESULT result = super.WM_WINDOWPOSCHANGING_ (wParam,lParam);
	if (result !is null) return result;
	if (display.lockActiveWindow) {
//		WINDOWPOS* lpwp = new WINDOWPOS ();
		WINDOWPOS* lpwp = cast(WINDOWPOS*)lParam;
//		OS.MoveMemory (lpwp, lParam, WINDOWPOS.sizeof);
		lpwp.flags |= OS.SWP_NOZORDER;
//		OS.MoveMemory (lParam, lpwp, WINDOWPOS.sizeof);
	}
	return result;
}

}
